// 商品数据访问对象
const db = uniCloud.database();
const dbCmd = db.command;
const productsCollection = db.collection('products');

class ProductsDAO {
  /**
   * 构造函数
   */
  constructor() {}

  /**
   * 添加商品
   * @param {Object} productData - 商品数据
   * @returns {Promise} 添加结果
   */
  async addProduct(productData) {
    try {
      // 添加创建时间和更新时间
      const now = new Date();
      const data = {
        ...productData,
        create_time: now,
        update_time: now,
        // 设置默认值
        sales: productData.sales || 0,
        view_count: productData.view_count || 0,
        score: productData.score || 5,
        status: productData.status !== undefined ? productData.status : 0,
        is_distribution: productData.is_distribution !== undefined ? productData.is_distribution : 0,
        distribution_rate: productData.distribution_rate || 0
      };
      
      const result = await productsCollection.add(data);
      return {
        success: true,
        data: result
      };
    } catch (error) {
      console.error('添加商品失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 根据ID获取商品
   * @param {String} id - 商品ID
   * @returns {Promise} 商品信息
   */
  async getProductById(id) {
    try {
      const result = await productsCollection.doc(id).get();
      return {
        success: true,
        data: result.data[0] || null
      };
    } catch (error) {
      console.error('获取商品失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 更新商品
   * @param {String} id - 商品ID
   * @param {Object} updateData - 更新数据
   * @returns {Promise} 更新结果
   */
  async updateProduct(id, updateData) {
    try {
      // 更新更新时间
      const updateDataWithTime = {
        ...updateData,
        update_time: new Date()
      };
      
      const result = await productsCollection.doc(id).update(updateDataWithTime);
      return {
        success: true,
        data: result
      };
    } catch (error) {
      console.error('更新商品失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 删除商品
   * @param {String} id - 商品ID
   * @returns {Promise} 删除结果
   */
  async deleteProduct(id) {
    try {
      const result = await productsCollection.doc(id).remove();
      return {
        success: true,
        data: result
      };
    } catch (error) {
      console.error('删除商品失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 查询商品列表
   * @param {Object} query - 查询条件
   * @param {Number} page - 页码
   * @param {Number} size - 每页大小
   * @returns {Promise} 查询结果
   */
  async queryProducts(query = {}, page = 1, size = 10) {
    try {
      // 构建查询条件
      const whereClause = {};
      
      // 按分类查询
      if (query.category_id) {
        whereClause.category_id = query.category_id;
      }
      
      // 按状态查询
      if (query.status !== undefined) {
        whereClause.status = query.status;
      }
      
      // 按是否分销查询
      if (query.is_distribution !== undefined) {
        whereClause.is_distribution = query.is_distribution;
      }
      
      // 关键词搜索
      if (query.keyword) {
        whereClause.name = dbCmd.regExp({
          regexp: query.keyword,
          options: 'i'
        });
      }
      
      // 价格范围查询
      if (query.min_price !== undefined && query.max_price !== undefined) {
        whereClause.current_price = dbCmd.gte(query.min_price).and(dbCmd.lte(query.max_price));
      } else if (query.min_price !== undefined) {
        whereClause.current_price = dbCmd.gte(query.min_price);
      } else if (query.max_price !== undefined) {
        whereClause.current_price = dbCmd.lte(query.max_price);
      }
      
      // 构建查询
      let dbQuery = productsCollection;
      if (Object.keys(whereClause).length > 0) {
        dbQuery = dbQuery.where(whereClause);
      }
      
      // 排序
      if (query.sort_field && query.sort_order) {
        dbQuery = dbQuery.orderBy(query.sort_field, query.sort_order);
      } else {
        // 默认按创建时间倒序
        dbQuery = dbQuery.orderBy('create_time', 'desc');
      }
      
      // 分页
      const skip = (page - 1) * size;
      const data = await dbQuery.skip(skip).limit(size).get();
      
      // 获取总数
      const count = await productsCollection.where(whereClause).count();
      
      return {
        success: true,
        data: {
          list: data.data,
          total: count.total,
          page,
          size,
          total_pages: Math.ceil(count.total / size)
        }
      };
    } catch (error) {
      console.error('查询商品列表失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 批量更新商品状态
   * @param {Array} ids - 商品ID数组
   * @param {Number} status - 状态值
   * @returns {Promise} 更新结果
   */
  async batchUpdateStatus(ids, status) {
    try {
      const result = await productsCollection.where({
        _id: dbCmd.in(ids)
      }).update({
        status,
        update_time: new Date()
      });
      
      return {
        success: true,
        data: result
      };
    } catch (error) {
      console.error('批量更新商品状态失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 增加商品库存
   * @param {String} id - 商品ID
   * @param {Number} quantity - 增加的数量
   * @returns {Promise} 更新结果
   */
  async increaseStock(id, quantity) {
    try {
      const result = await productsCollection.doc(id).update({
        stock: dbCmd.inc(quantity),
        update_time: new Date()
      });
      
      return {
        success: true,
        data: result
      };
    } catch (error) {
      console.error('增加商品库存失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 减少商品库存并增加销量
   * @param {String} id - 商品ID
   * @param {Number} quantity - 减少的数量
   * @returns {Promise} 更新结果
   */
  async decreaseStockAndIncreaseSales(id, quantity) {
    try {
      // 先检查库存是否足够
      const product = await this.getProductById(id);
      if (!product.success || !product.data) {
        return {
          success: false,
          error: '商品不存在'
        };
      }
      
      if (product.data.stock < quantity) {
        return {
          success: false,
          error: '库存不足'
        };
      }
      
      const result = await productsCollection.doc(id).update({
        stock: dbCmd.inc(-quantity),
        sales: dbCmd.inc(quantity),
        update_time: new Date()
      });
      
      return {
        success: true,
        data: result
      };
    } catch (error) {
      console.error('减少商品库存失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 增加商品浏览量
   * @param {String} id - 商品ID
   * @returns {Promise} 更新结果
   */
  async increaseViewCount(id) {
    try {
      const result = await productsCollection.doc(id).update({
        view_count: dbCmd.inc(1),
        update_time: new Date()
      });
      
      return {
        success: true,
        data: result
      };
    } catch (error) {
      console.error('增加商品浏览量失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }
}

module.exports = ProductsDAO;